// 云函数入口文件
const cloud = require('wx-server-sdk')

cloud.init({
  env: cloud.DYNAMIC_CURRENT_ENV
})

const db = cloud.database()
const giftCollection = db.collection('gift_list')
const MAX_LIMIT = 100 // 单次查询最大记录数限制

// 云函数入口函数
exports.main = async (event, context) => {
  const wxContext = cloud.getWXContext()
  const openid = wxContext.OPENID
  
  // 获取请求参数
  const { mode = 'all', keyword = '', statusFilter = 'all', page = 0, pageSize = 20 } = event
  
  let result = {
    success: true,
    statistics: {}, // 符合当前筛选条件的统计
    totalStatistics: {}, // 总体统计（无筛选）
    list: [],
    hasMore: false,
    totalCount: 0
  }
  
  try {
    // 构建基础查询条件，保证只查询当前用户的数据
    let baseQuery = { openid }
    
    // 如果有关键词，添加关键词搜索条件
    if (keyword) {
      baseQuery.name = db.RegExp({
        regexp: keyword,
        options: 'i'
      })
    }
    
    // 获取符合基础条件的总记录数（无状态筛选）
    const baseCountRes = await giftCollection.where(baseQuery).count()
    const baseTotal = baseCountRes.total
    console.log(`符合基础条件的记录总数: ${baseTotal}`)
    
    // 构建筛选查询条件（加上状态筛选）
    let filterQuery = { ...baseQuery }
    if (statusFilter === 'returned') {
      filterQuery.is_return_gift = true
    } else if (statusFilter === 'notReturned') {
      filterQuery.is_return_gift = false
    }
    
    // 获取符合筛选条件的总记录数
    const filterCountRes = await giftCollection.where(filterQuery).count()
    const filterTotal = filterCountRes.total
    console.log(`符合筛选条件的记录总数: ${filterTotal}`)
    
    // 总记录数用于分页计算
    result.totalCount = filterTotal
    
    // 根据模式执行不同的操作
    switch (mode) {
      case 'statistics': // 只获取统计数据
        await calculateTotalStatistics(baseQuery, result) // 总体统计
        await calculateStatistics(filterQuery, result) // 筛选后统计
        break
        
      case 'list': // 只获取列表数据
        await getList(filterQuery, page, pageSize, result)
        break
        
      case 'all': // 获取统计数据和列表数据
      default:
        await calculateTotalStatistics(baseQuery, result) // 总体统计
        await calculateStatistics(filterQuery, result) // 筛选后统计
        await getList(filterQuery, page, pageSize, result)
        break
    }
    
    return result
  } catch (err) {
    console.error('获取礼单数据失败', err)
    return {
      success: false,
      message: '获取礼单数据失败',
      error: err
    }
  }
}

/**
 * 计算总体统计数据（无筛选）
 * @param {Object} query 基础查询条件
 * @param {Object} result 结果对象引用
 */
async function calculateTotalStatistics(query, result) {
  try {
    // 获取符合条件的总记录数
    const countRes = await giftCollection.where(query).count()
    const total = countRes.total
    console.log(`总体统计: 总记录数: ${total}`)
    
    // 获取已回礼统计
    const returnedQuery = { 
      ...query,
      is_return_gift: true 
    }
    const returnedCountRes = await giftCollection.where(returnedQuery).count()
    const returnedCount = returnedCountRes.total
    console.log(`总体统计: 已回礼记录数: ${returnedCount}`)
    
    // 计算未回礼人数
    const notReturnedCount = total - returnedCount
    console.log(`总体统计: 未回礼记录数: ${notReturnedCount}`)
    
    // 计算总金额及已回礼金额（需要分批获取并统计）
    let totalAmount = 0
    let returnedAmount = 0
    const batchTimes = Math.ceil(total / MAX_LIMIT)
    console.log(`总体统计: 需要分${batchTimes}批查询计算总金额`)
    
    // 分批获取数据并计算总金额
    for (let i = 0; i < batchTimes; i++) {
      const res = await giftCollection
        .where(query)
        .skip(i * MAX_LIMIT)
        .limit(MAX_LIMIT)
        .get()
      
      console.log(`总体统计: 第${i+1}批获取到${res.data.length}条记录`)
      
      // 计算总金额和已回礼金额
      res.data.forEach(item => {
        if (item.amount && !isNaN(Number(item.amount))) {
          const amount = Number(item.amount)
          totalAmount += amount
          
          // 如果是已回礼的，累加到已回礼金额
          if (item.is_return_gift) {
            returnedAmount += amount
          }
        }
      })
    }
    
    // 计算未回礼金额
    const notReturnedAmount = totalAmount - returnedAmount
    
    // 设置总体统计结果
    result.totalStatistics = {
      totalCount: total,
      totalAmount: totalAmount.toFixed(2),
      returnedCount,
      notReturnedCount,
      returnedAmount: returnedAmount.toFixed(2),
      notReturnedAmount: notReturnedAmount.toFixed(2)
    }
    
    console.log(`总体统计结果: 总数=${total}, 总金额=${totalAmount.toFixed(2)}, 已回礼=${returnedCount}人 ${returnedAmount.toFixed(2)}元, 未回礼=${notReturnedCount}人 ${notReturnedAmount.toFixed(2)}元`)
  } catch (err) {
    console.error('计算总体统计数据失败', err)
    result.success = false
    result.message = '计算总体统计数据失败'
    result.error = err
  }
}

/**
 * 计算筛选后的统计数据
 * @param {Object} query 筛选查询条件
 * @param {Object} result 结果对象引用
 */
async function calculateStatistics(query, result) {
  try {
    // 获取符合条件的总记录数
    const countRes = await giftCollection.where(query).count()
    const total = countRes.total
    console.log(`筛选统计: 总记录数: ${total}`)
    
    // 计算总金额及已回礼金额（需要分批获取并统计）
    let totalAmount = 0
    let returnedAmount = 0
    const batchTimes = Math.ceil(total / MAX_LIMIT)
    console.log(`筛选统计: 需要分${batchTimes}批查询计算总金额`)
    
    // 分批获取数据并计算总金额
    for (let i = 0; i < batchTimes; i++) {
      const res = await giftCollection
        .where(query)
        .skip(i * MAX_LIMIT)
        .limit(MAX_LIMIT)
        .get()
      
      console.log(`筛选统计: 第${i+1}批获取到${res.data.length}条记录`)
      
      // 计算总金额和已回礼金额
      res.data.forEach(item => {
        if (item.amount && !isNaN(Number(item.amount))) {
          const amount = Number(item.amount)
          totalAmount += amount
          
          // 如果是已回礼的，累加到已回礼金额
          if (item.is_return_gift) {
            returnedAmount += amount
          }
        }
      })
    }
    
    // 对于筛选统计，如果是已回礼筛选，则返回的都是已回礼的数据
    let returnedCount = total
    let notReturnedCount = 0
    
    // 处理已回礼和未回礼的数量和金额
    if (query.hasOwnProperty('is_return_gift')) {
      // 如果查询条件已经指定了is_return_gift
      if (query.is_return_gift === true) {
        // 已回礼筛选
        returnedCount = total;
        returnedAmount = totalAmount;
        notReturnedCount = 0;
        notReturnedAmount = 0;
      } else {
        // 未回礼筛选
        returnedCount = 0;
        returnedAmount = 0;
        notReturnedCount = total;
        notReturnedAmount = totalAmount;
      }
    } else {
      // 全部记录，需要单独计算已回礼和未回礼数量
      const returnedQuery = { 
        ...query,
        is_return_gift: true 
      }
      const returnedCountRes = await giftCollection.where(returnedQuery).count()
      returnedCount = returnedCountRes.total
      notReturnedCount = total - returnedCount
      
      // 未回礼金额
      const notReturnedAmount = totalAmount - returnedAmount
    }
    
    // 设置筛选统计结果
    result.statistics = {
      totalCount: total,
      totalAmount: totalAmount.toFixed(2),
      returnedCount,
      notReturnedCount,
      returnedAmount: returnedAmount.toFixed(2),
      notReturnedAmount: (totalAmount - returnedAmount).toFixed(2)
    }
    
    console.log(`筛选统计结果: 总数=${total}, 总金额=${totalAmount.toFixed(2)}, 已回礼=${returnedCount}人 ${returnedAmount.toFixed(2)}元, 未回礼=${notReturnedCount}人 ${(totalAmount - returnedAmount).toFixed(2)}元`)
  } catch (err) {
    console.error('计算筛选统计数据失败', err)
    result.success = false
    result.message = '计算筛选统计数据失败'
    result.error = err
  }
}

/**
 * 获取列表数据
 * @param {Object} query 查询条件
 * @param {Number} page 页码
 * @param {Number} pageSize 每页记录数
 * @param {Object} result 结果对象引用
 */
async function getList(query, page, pageSize, result) {
  try {
    // 获取符合条件的记录总数
    const countRes = await giftCollection.where(query).count()
    const total = countRes.total
    console.log(`列表查询的总记录数: ${total}, 当前页: ${page}, 页大小: ${pageSize}`)
    
    // 查询数据
    const res = await giftCollection
      .where(query)
      .orderBy('amount', 'desc')  // 按金额降序排列
      .skip(page * pageSize)      // 分页跳过记录
      .limit(pageSize)            // 限制返回数量
      .get()
    
    console.log(`本次获取${res.data.length}条记录`)
    
    // 为每条数据添加滑动相关属性
    const list = res.data.map(item => {
      return {
        ...item,
        isTouchMove: false // 默认不处于滑动状态
      }
    })
    
    // 设置列表数据和分页信息
    result.list = list
    result.hasMore = list.length === pageSize && (page * pageSize + list.length < total)
    
    console.log(`是否还有更多数据: ${result.hasMore}`)
  } catch (err) {
    console.error('获取列表数据失败', err)
    result.success = false
    result.message = '获取列表数据失败'
    result.error = err
  }
} 